﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using log4net;
using Iudicium.Archivos;
using System.Web.Script.Serialization;
using Iudicium.Archivos.CRN;
using Iudicium.Utilitarios;

public partial class UserControls_Uploader : System.Web.UI.UserControl
{
    private static readonly ILog log = LogManager.GetLogger("LogFile");

    public enum ModeControl
    {
        Edit,
        Readonly,
        Insert
    }

    public enum ModeDownload
    {
        Link,
        Action
    }

    #region Propiedades

    public List<int> ArchivosSeleccionados
    {
        get
        {
            return ConvertJsonToList(SelectedFileIdsHiddenField.Value);;
        }
        set 
        {
            JavaScriptSerializer js = new JavaScriptSerializer();
            SelectedFileIdsHiddenField.Value = js.Serialize(value);
        } 
    }

    public List<int> ArchivosEliminados
    {
        get
        {
            return ConvertJsonToList(DeletedFileIdsHiddenField.Value);
        }
        set 
        {
            JavaScriptSerializer js = new JavaScriptSerializer();
            DeletedFileIdsHiddenField.Value = js.Serialize(value); 
        }
    }

    public TipoRelacionArchivo TipoRelacion
    {
        set { TipoRelacionHiddenField.Value = value.ToString(); }
        get 
        {
            TipoRelacionArchivo tipo = TipoRelacionArchivo.General;
            try
            {
                tipo = (TipoRelacionArchivo)Enum.Parse(typeof(TipoRelacionArchivo), TipoRelacionHiddenField.Value, true);
            }
            catch (Exception ex)
            {
                log.Error("No se pudo convertir TipoRelacionHiddenField.Value a un valor de tipo TipoRelacionArchivo", ex);
            }
            return tipo;
        }
    }

    public int ObjetoId
    {
        get
        {
            int objetoId = 0;
            try
            {
                objetoId = Convert.ToInt32(ObjetoIdHiddenField.Value);
            }
            catch (Exception ex)
            {
                log.Error("No se pudo convertir ObjetoIdHiddenField.Value a un valor entero", ex);
            }
            return objetoId;
        }
        set { ObjetoIdHiddenField.Value = value.ToString(); } 
    }

    protected string UploaderHandler
    {
        get { return VirtualPathUtility.ToAbsolute("~/UserControls/Handlers/LoadFileHandler.ashx"); }
    }

    protected string DeleteHandler
    {
        get { return VirtualPathUtility.ToAbsolute("~/UserControls/Handlers/DeleteFileHandler.ashx"); }
    }

    protected string RegiterInSessionHandler
    {
        get { return VirtualPathUtility.ToAbsolute("~/UserControls/Handlers/RegisterInSessionHandler.ashx"); }
    }

    protected string OpenFilePage
    {
        get { return VirtualPathUtility.ToAbsolute("~/Servicios/OpenFile.aspx"); }
    }

    protected string ExtensionAllowed
    {
        get 
        {
            JavaScriptSerializer js = new JavaScriptSerializer();
            return js.Serialize(Iudicium.Configuracion.ConfiguracionIudicium.GetExtensionAllowed());
        }
    }

    public int MaxFilesToUpload
    {
        set { MaxFilesToUploadHiddenField.Value = value < 1 ? "1" : value.ToString(); }
        get
        {
            int max = 0;
            try
            {
                max = Convert.ToInt32(MaxFilesToUploadHiddenField.Value);
            }
            catch (Exception ex)
            {
                log.Error("No se pudo convertir MaxFilesToUploadHiddenField.Value a un valor entero", ex);
            }
            return max;
        }
    }

    public string UploadButtonLabel
    {
        set { UploadButtonLiteral.Text = value; }
        get { return UploadButtonLiteral.Text; }
    }

    public ModeControl Mode
    {
        get
        {
            ModeControl mode = ModeControl.Insert;
            try
            {
                mode = (ModeControl)Enum.Parse(typeof(ModeControl), ModeHiddenField.Value, true);
            }
            catch (Exception ex)
            {
                log.Error("No se pudo convertir ModeHiddenField.Value a un valor de tipo ModeControl", ex);
            }
            return mode;
        }
        set { ModeHiddenField.Value = value.ToString(); }
    }

    public ModeDownload DonwloadAs
    {
        get
        {
            ModeDownload mode = ModeDownload.Action;
            try
            {
                mode = (ModeDownload)Enum.Parse(typeof(ModeDownload), DonwloadAsHiddenField.Value, true);
            }
            catch (Exception ex)
            {
                log.Error("No se pudo convertir ModeHiddenField.Value a un valor de tipo ModeControl", ex);
            }
            return mode;
        }
        set { DonwloadAsHiddenField.Value = value.ToString(); }
    }

    #endregion

    protected void Page_Load(object sender, EventArgs e)
    {

    }

    protected void Page_Prerender(object sender, EventArgs e)
    {
        Update();
    }

    public void Update()
    {
        if (Mode != ModeControl.Insert && ObjetoId > 0)
        {
            List<RelacionArchivo> lista = new List<RelacionArchivo>();
            try
            {
                lista = ArchivoCRN.GetArchivosByObjeto(ObjetoId, TipoRelacion);
            }
            catch (Exception ex)
            {
                log.Error("No se pudo obtener la lista de archivos para el objeto " + ObjetoId +
                    " para la relacion con " + TipoRelacion.ToString(), ex);
            }
            FilesRepeater.DataSource = lista;
            FilesRepeater.DataBind();
        }
        else
        {
            List<RelacionArchivo> lista = new List<RelacionArchivo>();
            FilesRepeater.DataSource = lista;
            FilesRepeater.DataBind();
        }
        if (Mode == ModeControl.Readonly)
            UploaderPanel.Visible = false;
    }

    public void DownloadButton_Click(object sender, EventArgs e)
    {
        int fileToDownload = 0;
        try
        {
            fileToDownload = Convert.ToInt32(FileIdToDownloadHiddenField.Value);
        }
        catch (Exception ex)
        {
            log.Error("No se pudo convertir FileIdToDownloadHiddenField.Value a un valor entero", ex);
        }

        if (fileToDownload <= 0)
            return;

        Archivo objArchivo = null;
        try
        {
            objArchivo = ArchivoCRN.GetArchivoById(fileToDownload);
        }
        catch (Exception ex)
        {
            log.Error("Ocurrio un error al obtener el archivo seleccionado", ex);
        }

        if (objArchivo == null)
            return;

        Response.Clear();
        byte[] document = Utilitarios.GetBytesFromFile(objArchivo.RutaAlmacenamiento);
        string extension = objArchivo.Extension;
        string fileName = objArchivo.Nombre;

        string mimeType = Utilitarios.GetFileMIMEType(extension);
        if (mimeType != null)
        {
            Response.ContentType = mimeType;
        }
        Response.AddHeader("Content-Disposition", "attachment;Filename=\"" + HttpUtility.UrlPathEncode(fileName) + "\"");
        Response.BinaryWrite(document);
        Response.Flush();
        Response.End();
    }
    protected void FilesRepeater_ItemDataBound(object sender, RepeaterItemEventArgs e)
    {
        Label archivoIdHiddenLabel = (Label)e.Item.FindControl("ArchivoIdHiddenLabel");
        if (archivoIdHiddenLabel == null)
            return;

        HyperLink deleteButton = (HyperLink)e.Item.FindControl("DeleteButton");
        if (deleteButton != null && Mode != ModeControl.Readonly)
            deleteButton.Attributes["FileId"] = archivoIdHiddenLabel.Text;

        if (Mode == ModeControl.Readonly)
            deleteButton.Visible = false;

        HyperLink downloadButton = (HyperLink)e.Item.FindControl("DownloadButton");
        if (downloadButton != null)
            downloadButton.Attributes["FileId"] = archivoIdHiddenLabel.Text;
    }

    public List<int> ConvertJsonToList(string json)
    {
        List<int> list = new List<int>();
        JavaScriptSerializer js = new JavaScriptSerializer();
        try
        {
            list = js.Deserialize<List<int>>(json);
        }
        catch (Exception ex)
        {
            log.Error("No se pudo convertir string json a List<int>", ex);
        }
        return list;
    }
}